/*
 * Filename:    IndicatorConfigServiceImpl.java
 * Copyright:   2014 中国平安保险（集团）股份有限公司 版权所有
 * Company:     平安科技养老险及健康险系统开发部
 * Create at:   2014年10月10日
 * 
 */
package com.paic.mhis.hcpms.quota.indicatorconfig.biz.service.impl;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.paic.mhis.core.user.biz.service.RegionContext;
import com.paic.mhis.core.user.dto.RegionDTO;
import com.paic.mhis.hcpms.common.mathCal.MathExtendsUtil;
import com.paic.mhis.hcpms.quota.indicatorconfig.biz.service.IndicatorConfigService;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorAreaDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorBaseDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorConfigDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorOrgDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorTreeDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorTypeDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorValueDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorValues4CalDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.dto.IndicatorWarnValueDTO;
import com.paic.mhis.hcpms.quota.indicatorconfig.exception.IndicatorConfigException;
import com.paic.mhis.hcpms.quota.indicatorconfig.intergration.dao.IndicatorConfigDAO;

/**
 * 
 * @author EX-XIEQI001
 * 
 */
@Service("indicatorConfigService")
public class IndicatorConfigServiceImpl implements IndicatorConfigService {

	@Autowired
	public IndicatorConfigDAO indicatorConfigDao;

	// 锁机制
	public final Lock lock = new ReentrantLock();

	private static BigDecimal TWO = BigDecimal.ONE.add(BigDecimal.ONE);
	private static BigDecimal THREE = TWO.add(BigDecimal.ONE);

	@Override
	public Map<String, Object> getIndicatorAddAll(Map<String, Object> map) {

		String regionCode = "A0201";
		map.put("regionCode", regionCode);

		int total = indicatorConfigDao.queryIndicatorAddTotal(map);
		List<IndicatorBaseDTO> list = null;
		if (total > 0) {
			list = indicatorConfigDao.queryIndicatorAddAll(map);
		}
		Map<String, Object> reMap = new HashMap<String, Object>();
		reMap.put("total", total);
		reMap.put("root", list);
		return reMap;
	}

	@Override
	public List<IndicatorBaseDTO> getIndicatorBaseAll(String regionCode) {
		return indicatorConfigDao.queryIndicatorBaseAll(regionCode);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void addIndicators(List<String> kpiIds, String username, String regionCode) throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(regionCode);

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行新增指标，指标分析结束后才能进行新增操作。");
			}

			// 循环添加指标
			for (String kpiId : kpiIds) {

				Map<String, Object> map = new HashMap<String, Object>();
				map.put("regionCode", regionCode);
				map.put("kpiId", kpiId);
				IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
				if (null == areaDto) {
					throw new IndicatorConfigException("请刷新之后再操作");
				}

				IndicatorConfigDTO configDto = new IndicatorConfigDTO();

				if (!"0".equals(areaDto.getIsValid())) {
					Integer version = Integer.parseInt(areaDto.getVersion());
					version = version + 1;
					configDto.setRegionCode(regionCode);
					configDto.setKpiId(kpiId);
					configDto.setVersion(version.toString());
					// 新增指标
					addIndicatorConfig(configDto, username);
					// 更新区域指标配置表
					areaDto.setIsValid("0");
					areaDto.setVersion(version.toString());
					areaDto.setUpdatedBy(username);
					indicatorConfigDao.updateIndicatorArea(areaDto);

				} else if (!"0".equals(areaDto.getIsValid())) {
					configDto.setRegionCode(regionCode);
					configDto.setKpiId(kpiId);
					configDto.setVersion(areaDto.getVersion());
					// 新增指标
					addIndicatorConfig(configDto, username);
					// 更新区域指标配置表
					areaDto.setIsValid("0");
					areaDto.setUpdatedBy(username);
					indicatorConfigDao.updateIndicatorArea(areaDto);
				}
			}

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}
	}

	// 单条新增指标
	private void addIndicatorConfig(IndicatorConfigDTO configDto, String username) throws IndicatorConfigException {
		try {
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", configDto.getRegionCode());
			map.put("kpiId", configDto.getKpiId());

			IndicatorBaseDTO baseDto = indicatorConfigDao.queryIndicatorBase(map);
			if (null != baseDto) {
				configDto.setShowType(baseDto.getShowType());
				configDto.setVisitType(baseDto.getVisitType());

				configDto.setCreatedBy(username);
				configDto.setCreatedDate(new Date());
				configDto.setUpdatedBy(username);
				configDto.setUpdatedDate(new Date());

				// 新增指标配置表
				String kpiConfigId = indicatorConfigDao.insertIndicatorConfig(configDto);

				// 获取默认的指标类型数据
				List<IndicatorTypeDTO> typeDtos = indicatorConfigDao.queryIndicatorTypeBaseAll(configDto.getKpiId());

				// 新增指标类型表
				if (null != typeDtos && typeDtos.size() > 0) {

					for (IndicatorTypeDTO typeDto : typeDtos) {
						typeDto.setKpiConfigId(kpiConfigId);
						typeDto.setIsValid("0");
						typeDto.setCreatedBy(username);
						typeDto.setCreatedDate(new Date());
						typeDto.setUpdatedBy(username);
						typeDto.setUpdatedDate(new Date());
					}

					indicatorConfigDao.insertIndicatorTypes(typeDtos);
				}
				// 获取默认的指标机构关系表数据
				List<IndicatorOrgDTO> orgDtos = indicatorConfigDao.queryIndicatorOrgBaseAll(configDto.getKpiId());

				// 新增指标机构关系表
				if (null != orgDtos && orgDtos.size() > 0) {

					for (IndicatorOrgDTO orgDto : orgDtos) {
						orgDto.setKpiConfigId(kpiConfigId);
						orgDto.setIsValid("0");
						orgDto.setCreatedBy(username);
						orgDto.setCreatedDate(new Date());
						orgDto.setUpdatedBy(username);
						orgDto.setUpdatedDate(new Date());
					}

					indicatorConfigDao.insertIndicatorOrgs(orgDtos);
				}

				// 获取默认的指标阈值数据
				List<IndicatorValueDTO> valueDtos = indicatorConfigDao.queryIndicatorValueBaseAll(configDto.getKpiId());

				// 新增阈值表
				if (null != valueDtos && valueDtos.size() > 0) {

					for (IndicatorValueDTO valueDto : valueDtos) {
						valueDto.setKpiConfigId(kpiConfigId);
						valueDto.setIsValid("0");
						valueDto.setCreatedBy(username);
						valueDto.setCreatedDate(new Date());
						valueDto.setUpdatedBy(username);
						valueDto.setUpdatedDate(new Date());
					}

					indicatorConfigDao.insertIndicatorValues(valueDtos);
				}
				// 获取默认的指标预警规则
				List<IndicatorWarnValueDTO> warnDtos = indicatorConfigDao.queryIndicatorWarnValueBaseAll(configDto
						.getKpiId());

				// 新增指标机构关系表
				if (null != warnDtos && warnDtos.size() > 0) {

					for (IndicatorWarnValueDTO warnDto : warnDtos) {
						warnDto.setKpiConfigId(kpiConfigId);
						warnDto.setIsValid("0");
						warnDto.setCreatedBy(username);
						warnDto.setCreatedDate(new Date());
						warnDto.setUpdatedBy(username);
						warnDto.setUpdatedDate(new Date());
					}

					indicatorConfigDao.insertIndicatorWarnValue(warnDtos);
				}

			}
		} catch (Exception e) {
			throw new IndicatorConfigException("新增指标出错! 请联系管理员");
		}

	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void deleteIndicator(String kpiId, String uaerName, String regionCode) throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(regionCode);

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行删除指标，指标分析结束后才能进行删除操作。");
			}
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", regionCode);
			map.put("kpiId", kpiId);
			IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
			if (null == areaDto) {
				throw new IndicatorConfigException("请刷新之后再操作");
			}
			areaDto.setIsValid("1");
			areaDto.setUpdatedBy(uaerName);
			areaDto.setUpdatedDate(new Date());
			indicatorConfigDao.updateIndicatorArea(areaDto);

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}

	}

	@Override
	public IndicatorBaseDTO getIndicatorsInfo(String kpiId, String regionCode) throws IndicatorConfigException {
		Map<String, Object> map = new HashMap<String, Object>();
		try {
			map.put("regionCode", regionCode);
			map.put("kpiId", kpiId);

			IndicatorBaseDTO baseDto = indicatorConfigDao.queryIndicatorBase(map);
			// 清空基表数据
			if (null != baseDto) {
				baseDto.setShowType("");
				baseDto.setVisitType("");
			}

			IndicatorConfigDTO configDto = null;
			if (null != baseDto) {
				IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
				if (areaDto != null && "0".equals(areaDto.getIsValid())) {
					baseDto.setDateStart(areaDto.getDateStart());
					baseDto.setDateEnd(areaDto.getDateEnd());

					map.put("version", areaDto.getVersion());
					configDto = indicatorConfigDao.queryIndicatorConfig(map);
				} else {
					return null;
				}
			}

			if (null != configDto) {
				// 维度
				baseDto.setShowType(configDto.getShowType());
				// 业务场景
				baseDto.setVisitType(configDto.getVisitType());
				// 是否有效
				baseDto.setIsValid(configDto.getIsValid());

				// 指标类型集合
				List<IndicatorTypeDTO> typeDtos = indicatorConfigDao.queryIndicatorTypeAll(configDto.getId());
				baseDto.setTypeDatas(typeDtos);

				// 指标机构关系集合
				List<IndicatorOrgDTO> orgDtos = indicatorConfigDao.queryIndicatorOrgAll(configDto.getId());
				baseDto.setOrgDatas(orgDtos);

				// 指标阈值集合
				List<IndicatorValueDTO> valueDtos = indicatorConfigDao.queryIndicatorValueAll(configDto.getId());
				baseDto.setValueDatas(valueDtos);

				// 指标阈值集合
				List<IndicatorWarnValueDTO> warnValueDtos = indicatorConfigDao.queryIndicatorWarnValueAll(configDto
						.getId());
				baseDto.setWarnValueDatas(warnValueDtos);

			}
			return baseDto;
		} catch (Exception e) {
			throw new IndicatorConfigException("查询数据库出错，请联系管理员");
		}

	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void updateIndicatorInfo(List<String> kpiTypes, List<String> orgTypes, String showType, String visitType,
			String isValid, String kpiId, String username, String regionCode) throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(regionCode);

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行删除指标，指标分析结束后才能进行删除操作。");
			}
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", regionCode);
			map.put("kpiId", kpiId);
			IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
			if (null == areaDto || "1".equals(areaDto.getIsValid())) {
				throw new IndicatorConfigException("请刷新之后再操作");
			}
			// 是否需要重新生成版本
			if ("0".equals(areaDto.getIsChang())) {
				IndicatorConfigDTO configDto = new IndicatorConfigDTO();
				Integer version = Integer.parseInt(areaDto.getVersion());
				version = version + 1;
				configDto.setRegionCode(regionCode);
				configDto.setKpiId(kpiId);
				configDto.setVersion(version.toString());
				configDto.setShowType(showType);
				configDto.setVisitType(visitType);
				configDto.setIsValid(isValid);
				configDto.setCreatedBy(username);
				configDto.setCreatedDate(new Date());
				configDto.setUpdatedBy(username);
				configDto.setUpdatedDate(new Date());
				// 新增指标配置表
				String kpiConfigId = indicatorConfigDao.insertIndicatorConfig(configDto);

				// 新增指标
				this.updateIndicatorConfig(kpiTypes, orgTypes, kpiConfigId, kpiId, username);

				// 复制阈值集合信息
				map.put("version", areaDto.getVersion());
				IndicatorConfigDTO dto = indicatorConfigDao.queryIndicatorConfig(map);

				this.copyIndicatorValue(dto.getId(), kpiConfigId, username);

				// 更新区域指标配置表
				areaDto.setVersion(version.toString());
				areaDto.setIsChang("1");
				areaDto.setUpdatedBy(username);
				indicatorConfigDao.updateIndicatorArea(areaDto);
			} else {
				map.put("version", areaDto.getVersion());
				IndicatorConfigDTO configDto = indicatorConfigDao.queryIndicatorConfig(map);
				if (configDto != null) {
					indicatorConfigDao.deleteIndicatorType(configDto.getId());
					indicatorConfigDao.deleteIndicatorOrg(configDto.getId());
					this.updateIndicatorConfig(kpiTypes, orgTypes, configDto.getId(), kpiId, username);
					configDto.setShowType(showType);
					configDto.setVisitType(visitType);
					configDto.setIsValid(isValid);
					indicatorConfigDao.updateIndicatorConfig(configDto);
				}

			}

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}
	}

	// 修改指标信息
	private void updateIndicatorConfig(List<String> kpiTypes, List<String> orgTypes, String kpiConfigId, String kpiId,
			String username) throws IndicatorConfigException {
		try {

			// 获取默认的指标类型数据
			List<IndicatorTypeDTO> typeDtos = new ArrayList<IndicatorTypeDTO>();
			for (String kpiType : kpiTypes) {
				IndicatorTypeDTO typeDto = new IndicatorTypeDTO();
				typeDto.setKpiConfigId(kpiConfigId);
				typeDto.setKpiId(kpiId);
				typeDto.setKpiType(kpiType);
				typeDto.setIsValid("0");
				typeDto.setCreatedBy(username);
				typeDto.setCreatedDate(new Date());
				typeDto.setUpdatedBy(username);
				typeDto.setUpdatedDate(new Date());
				typeDtos.add(typeDto);
			}

			// 新增指标类型表
			if (null != typeDtos && typeDtos.size() > 0) {
				indicatorConfigDao.insertIndicatorTypes(typeDtos);
			}
			// 获取默认的指标机构关系表数据
			List<IndicatorOrgDTO> orgDtos = new ArrayList<IndicatorOrgDTO>();
			for (String orgType : orgTypes) {
				IndicatorOrgDTO orgDto = new IndicatorOrgDTO();
				orgDto.setKpiConfigId(kpiConfigId);
				orgDto.setKpiId(kpiId);
				orgDto.setOrgType(orgType);
				orgDto.setIsValid("0");
				orgDto.setCreatedBy(username);
				orgDto.setCreatedDate(new Date());
				orgDto.setUpdatedBy(username);
				orgDto.setUpdatedDate(new Date());
				orgDtos.add(orgDto);
			}

			// 新增指标机构关系表
			if (null != orgDtos && orgDtos.size() > 0) {
				indicatorConfigDao.insertIndicatorOrgs(orgDtos);
			}

		} catch (Exception e) {
			throw new IndicatorConfigException("修改指标出错! 请联系管理员");
		}

	}

	// 复制阈值集合信息
	private void copyIndicatorValue(String kpiConfigId, String newKpiConfigId, String username)
			throws IndicatorConfigException {
		try {
			List<IndicatorValueDTO> valueDtos = indicatorConfigDao.queryIndicatorValueAll(kpiConfigId);

			// 新增阈值表
			if (null != valueDtos && valueDtos.size() > 0) {

				for (IndicatorValueDTO valueDto : valueDtos) {
					valueDto.setId(null);
					valueDto.setIsValid("0");
					valueDto.setCreatedBy(username);
					valueDto.setCreatedDate(new Date());
					valueDto.setUpdatedBy(username);
					valueDto.setUpdatedDate(new Date());
					valueDto.setKpiConfigId(newKpiConfigId);
				}

				indicatorConfigDao.insertIndicatorValues(valueDtos);
			}

		} catch (Exception e) {
			throw new IndicatorConfigException("修改指标出错! 请联系管理员");
		}

	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void updateIndicatorValue(String id, String kpiId, String value, String username, String regionCode)
			throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(regionCode);

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行删除指标，指标分析结束后才能进行删除操作。");
			}

			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", regionCode);
			map.put("kpiId", kpiId);
			IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
			if (null == areaDto || "1".equals(areaDto.getIsValid())) {
				throw new IndicatorConfigException("请刷新之后再操作");
			}
			// 是否需要重新生成版本
			if ("0".equals(areaDto.getIsChang())) {
				map.put("version", areaDto.getVersion());
				IndicatorConfigDTO configDto = indicatorConfigDao.queryIndicatorConfig(map);
				if (configDto != null) {
					Integer version = Integer.parseInt(areaDto.getVersion());
					version = version + 1;
					configDto.setVersion(version.toString());
					this.copyIndicatorConfig(configDto, id, value, username, false);
					areaDto.setVersion(version.toString());
					areaDto.setIsChang("1");
					areaDto.setUpdatedBy(username);
					indicatorConfigDao.updateIndicatorArea(areaDto);
				}
			} else {
				Map<String, Object> valueMap = new HashMap<String, Object>();
				valueMap.put("value", value);
				valueMap.put("valueId", id);
				indicatorConfigDao.updateIndicatorValue(valueMap);
			}

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}
	}

	/**
	 * 复制指标信息
	 * 
	 * @param configDto
	 * @param id
	 * @param value
	 * @param username
	 * @param isFlag
	 *            判断是指标参数修改还是指标预警指标修改
	 * @throws IndicatorConfigException
	 */
	private void copyIndicatorConfig(IndicatorConfigDTO configDto, String id, String value, String username,
			boolean isFlag) throws IndicatorConfigException {
		try {
			String kpiConfigId = configDto.getId();
			configDto.setCreatedBy(username);
			configDto.setCreatedDate(new Date());
			configDto.setUpdatedBy(username);
			configDto.setUpdatedDate(new Date());

			// 新增指标配置表
			String newKpiConfigId = indicatorConfigDao.insertIndicatorConfig(configDto);

			List<IndicatorTypeDTO> typeDtos = indicatorConfigDao.queryIndicatorTypeAll(kpiConfigId);

			// 新增指标类型表
			if (null != typeDtos && typeDtos.size() > 0) {
				for (IndicatorTypeDTO typeDto : typeDtos) {
					typeDto.setKpiConfigId(newKpiConfigId);
					typeDto.setIsValid("0");
					typeDto.setCreatedBy(username);
					typeDto.setCreatedDate(new Date());
					typeDto.setUpdatedBy(username);
					typeDto.setUpdatedDate(new Date());
				}

				indicatorConfigDao.insertIndicatorTypes(typeDtos);
			}
			// 指标机构关系集合
			List<IndicatorOrgDTO> orgDtos = indicatorConfigDao.queryIndicatorOrgAll(kpiConfigId);

			// 新增指标机构关系表
			if (null != orgDtos && orgDtos.size() > 0) {

				for (IndicatorOrgDTO orgDto : orgDtos) {
					orgDto.setKpiConfigId(newKpiConfigId);
					orgDto.setIsValid("0");
					orgDto.setCreatedBy(username);
					orgDto.setCreatedDate(new Date());
					orgDto.setUpdatedBy(username);
					orgDto.setUpdatedDate(new Date());
				}

				indicatorConfigDao.insertIndicatorOrgs(orgDtos);
			}

			// 指标阈值集合
			List<IndicatorValueDTO> valueDtos = indicatorConfigDao.queryIndicatorValueAll(kpiConfigId);

			// 新增阈值表
			if (null != valueDtos && valueDtos.size() > 0) {
				// 获取指标阈值数据
				for (IndicatorValueDTO valueDto : valueDtos) {
					if (isFlag == false && id.equals(valueDto.getId())) {
						valueDto.setValue(value);
					}
					valueDto.setKpiConfigId(newKpiConfigId);
					valueDto.setIsValid("0");
					valueDto.setCreatedBy(username);
					valueDto.setCreatedDate(new Date());
					valueDto.setUpdatedBy(username);
					valueDto.setUpdatedDate(new Date());

				}
				indicatorConfigDao.insertIndicatorValues(valueDtos);
			}
			// 指标预警规则集合
			List<IndicatorWarnValueDTO> warnValueDtos = indicatorConfigDao.queryIndicatorWarnValueAll(kpiConfigId);

			// 新增预警规则表
			if (null != warnValueDtos && warnValueDtos.size() > 0) {
				// 获取指标预警规则数据
				for (IndicatorWarnValueDTO warnValueDto : warnValueDtos) {
					if (isFlag == true && id.equals(warnValueDto.getId())) {
						warnValueDto.setWarnValue(value);
					}
					warnValueDto.setKpiConfigId(newKpiConfigId);
					warnValueDto.setIsValid("0");
					warnValueDto.setCreatedBy(username);
					warnValueDto.setCreatedDate(new Date());
					warnValueDto.setUpdatedBy(username);
					warnValueDto.setUpdatedDate(new Date());
				}
				indicatorConfigDao.insertIndicatorWarnValue(warnValueDtos);
			}
		} catch (Exception e) {
			throw new IndicatorConfigException("修改指标出错! 请联系管理员");
		}

	}

	@Override
	public List<IndicatorTreeDTO> getIndicatorTreeAll() {
		// 获取所有的统筹区域
		RegionContext rc = RegionContext.get();
		List<RegionDTO> regionDtos = rc.getRegions();
		List<IndicatorTreeDTO> treeDtos = new ArrayList<IndicatorTreeDTO>();
		for (RegionDTO regionDto : regionDtos) {
			IndicatorTreeDTO treeDto = new IndicatorTreeDTO();
			treeDto.setText(regionDto.getName());
			treeDto.setRegionCode(regionDto.getCode());
			List<IndicatorTreeDTO> dtos = new ArrayList<IndicatorTreeDTO>();

			List<IndicatorBaseDTO> baseDtos = indicatorConfigDao.queryIndicatorBaseAll(regionDto.getCode());

			for (IndicatorBaseDTO baseDto : baseDtos) {
				IndicatorTreeDTO dto = new IndicatorTreeDTO();
				dto.setText(baseDto.getKpiName());
				dto.setRegionCode(regionDto.getCode());
				dto.setKpiId(baseDto.getKpiId());
				dtos.add(dto);
			}
			if (null != dtos && dtos.size() > 0) {
				treeDto.setNodes(dtos);
			}
			treeDtos.add(treeDto);
		}
		return treeDtos;
	}

	@Override
	public List<IndicatorTreeDTO> getIndicatorTreeAll(String userName) {
		// 获取所有的统筹区域
		List<RegionDTO> regionDtos = indicatorConfigDao.queryRegionByUserName(userName);
		List<IndicatorTreeDTO> treeDtos = new ArrayList<IndicatorTreeDTO>();
		for (RegionDTO regionDto : regionDtos) {
			IndicatorTreeDTO treeDto = new IndicatorTreeDTO();
			treeDto.setText(regionDto.getName());
			treeDto.setRegionCode(regionDto.getCode());
			List<IndicatorTreeDTO> dtos = new ArrayList<IndicatorTreeDTO>();

			List<IndicatorBaseDTO> baseDtos = indicatorConfigDao.queryIndicatorBaseAll(regionDto.getCode());

			for (IndicatorBaseDTO baseDto : baseDtos) {
				IndicatorTreeDTO dto = new IndicatorTreeDTO();
				dto.setText(baseDto.getKpiName());
				dto.setRegionCode(regionDto.getCode());
				dto.setKpiId(baseDto.getKpiId());
				dtos.add(dto);
			}
			if (null != dtos && dtos.size() > 0) {
				treeDto.setNodes(dtos);
			}
			treeDtos.add(treeDto);
		}
		return treeDtos;
	}

	@Override
	public void addIndicatorAll(String username, String regionCode) throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(regionCode);

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行删除指标，指标分析结束后才能进行删除操作。");
			}

			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", regionCode);
			List<IndicatorAreaDTO> areaDtos = indicatorConfigDao.queryIndicatorAreaAll(regionCode);
			for (IndicatorAreaDTO areaDto : areaDtos) {
				IndicatorConfigDTO configDto = new IndicatorConfigDTO();
				// if ("0".equals(areaDto.getIsValid())) {
				Integer version = Integer.parseInt(areaDto.getVersion());
				version = version + 1;
				configDto.setRegionCode(regionCode);
				configDto.setIsValid("0");
				configDto.setKpiId(areaDto.getKpiId());
				configDto.setVersion(version.toString());
				// 新增指标
				addIndicatorConfig(configDto, username);
				// 更新区域指标配置表
				areaDto.setIsValid("0");
				areaDto.setVersion(version.toString());
				areaDto.setUpdatedBy(username);
				indicatorConfigDao.updateIndicatorArea(areaDto);
				// }
			}

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}

	}

	@Override
	public void updateIndicatorsWarnValue(String id, String kpiId, String warnValue, String username, String regionCode)
			throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(regionCode);

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行删除指标，指标分析结束后才能进行删除操作。");
			}

			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", regionCode);
			map.put("kpiId", kpiId);
			IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
			if (null == areaDto || "1".equals(areaDto.getIsValid())) {
				throw new IndicatorConfigException("请刷新之后再操作");
			}
			// 是否需要重新生成版本
			if ("0".equals(areaDto.getIsChang())) {
				map.put("version", areaDto.getVersion());
				IndicatorConfigDTO configDto = indicatorConfigDao.queryIndicatorConfig(map);
				if (configDto != null) {
					Integer version = Integer.parseInt(areaDto.getVersion());
					version = version + 1;
					configDto.setVersion(version.toString());
					this.copyIndicatorConfig(configDto, id, warnValue, username, true);
					areaDto.setVersion(version.toString());
					areaDto.setIsChang("1");
					areaDto.setUpdatedBy(username);
					indicatorConfigDao.updateIndicatorArea(areaDto);
				}
			} else {
				Map<String, Object> valueMap = new HashMap<String, Object>();
				valueMap.put("warnValue", warnValue);
				valueMap.put("id", id);
				indicatorConfigDao.updateIndicatorWarnValue(valueMap);
			}

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}

	}

	public void updateIndicatorsWarnValue(String username, IndicatorWarnValueDTO extendVal)
			throws IndicatorConfigException {
		try {
			lock.lock();
			boolean flag = indicatorConfigDao.isLockIndicator(extendVal.getRegionCode());

			if (flag) {
				throw new IndicatorConfigException("正在执行指标分析，不能进行删除指标，指标分析结束后才能进行删除操作。");
			}

			Map<String, Object> map = new HashMap<String, Object>();
			map.put("regionCode", extendVal.getRegionCode());
			map.put("kpiId", extendVal.getKpiId());
			IndicatorAreaDTO areaDto = indicatorConfigDao.queryIndicatorArea(map);
			if (null == areaDto || "1".equals(areaDto.getIsValid())) {
				throw new IndicatorConfigException("请刷新之后再操作");
			}
			// 是否需要重新生成版本
			if ("0".equals(areaDto.getIsChang())) {
				map.put("version", areaDto.getVersion());
				IndicatorConfigDTO configDto = indicatorConfigDao.queryIndicatorConfig(map);
				if (configDto != null) {
					Integer version = Integer.parseInt(areaDto.getVersion());
					version = version + 1;
					configDto.setVersion(version.toString());
					this.copyIndicatorConfig(configDto, extendVal.getId(), null, username, true);
					areaDto.setVersion(version.toString());
					areaDto.setIsChang("1");
					areaDto.setUpdatedBy(username);
					indicatorConfigDao.updateIndicatorArea(areaDto);
				}
			} else {
				Map<String, Object> valueMap = new HashMap<String, Object>();
				valueMap.put("lowerLimit", extendVal.getLowerLimit());
				valueMap.put("upperLimit", extendVal.getUpperLimit());
				valueMap.put("timeBegin", extendVal.getTimeBegin());
				valueMap.put("timeEnd", extendVal.getTimeEnd());
				valueMap.put("id", extendVal.getId());
				indicatorConfigDao.updateIndicatorWarnValue(valueMap);
			}

		} catch (IndicatorConfigException e) {
			throw e;
		} catch (Exception e) {
			throw new IndicatorConfigException("请刷新之后再操作，或者联系管理员");
		} finally {
			lock.unlock(); // 释放锁
		}
	}

	@Override
	public Map<String, Object> calKpiValues(String kind, IndicatorWarnValueDTO extendVal)
			throws IndicatorConfigException {
		Map<String, Object> valueMap = new HashMap<String, Object>();
		valueMap.put("timeBegin", extendVal.getTimeBegin());
		valueMap.put("timeEnd", extendVal.getTimeEnd());
		valueMap.put("kpiCode", extendVal.getKpiId());
		valueMap.put("regionCode", extendVal.getRegionCode());

		List<IndicatorValues4CalDTO> rstList = indicatorConfigDao.queryKpiValues4Cal(valueMap);
		// 同比
		List<BigDecimal> rList = new ArrayList<BigDecimal>();
		for (IndicatorValues4CalDTO sec : rstList) {
			if ("01".equalsIgnoreCase(kind)) {
				rList.add(sec.getPeriodRatio());
			} else if ("02".equalsIgnoreCase(kind)) {
				rList.add(sec.getChainRatio());
			} else if ("03".equalsIgnoreCase(kind)) {
				rList.add(sec.getIncremental());
			}
		}
		MathExtendsUtil.EachValues ev = new MathExtendsUtil.EachValues(rList);
		Map<String, Object> rMap = new HashMap<String, Object>();
		MathContext mc = new MathContext(4, RoundingMode.HALF_UP);

		rMap.put("average", ev.getAverage().multiply(BigDecimal.ONE, mc));
		rMap.put("variance", ev.getVarianceStd().multiply(BigDecimal.ONE, mc));

		rMap.put("highL",
				ev.getAverage().subtract(ev.getVarianceStd().multiply(BigDecimal.ONE, mc)).multiply(BigDecimal.ONE, mc));
		rMap.put("highH",
				ev.getAverage().add(ev.getVarianceStd().multiply(BigDecimal.ONE, mc)).multiply(BigDecimal.ONE, mc));

		rMap.put("middleL", ev.getAverage().subtract(ev.getVarianceStd().multiply(TWO, mc))
				.multiply(BigDecimal.ONE, mc));
		rMap.put("middleH", ev.getAverage().add(ev.getVarianceStd().multiply(TWO, mc)).multiply(BigDecimal.ONE, mc));

		rMap.put("lowL", ev.getAverage().subtract(ev.getVarianceStd().multiply(THREE, mc)).multiply(BigDecimal.ONE, mc));
		rMap.put("lowH", ev.getAverage().add(ev.getVarianceStd().multiply(THREE, mc)).multiply(BigDecimal.ONE, mc));

		return rMap;
	}

	@Override
	public int numOfOrg(Map<String,Object> map) {
		return indicatorConfigDao.numOfOrg(map);
	}

}
